#include "enemys.hh"

namespace enemys {
    Pelagic_Grouper::Pelagic_Grouper(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Pelagic_Grouper::skill::Seaward_Slash::name;
        this->skill1_targets = enemy_settings::Pelagic_Grouper::skill::Seaward_Slash::Target;
        this->skill1_min_attack = enemy_settings::Pelagic_Grouper::skill::Seaward_Slash::min_attack;
        this->skill1_max_attack = enemy_settings::Pelagic_Grouper::skill::Seaward_Slash::max_attack;
        this->skill1_crit = enemy_settings::Pelagic_Grouper::skill::Seaward_Slash::crit;
        this->skill2_name = enemy_settings::Pelagic_Grouper::skill::Spearfishing::name;
        this->skill2_targets = enemy_settings::Pelagic_Grouper::skill::Spearfishing::Target;
        this->skill2_min_attack = enemy_settings::Pelagic_Grouper::skill::Spearfishing::min_attack;
        this->skill2_max_attack = enemy_settings::Pelagic_Grouper::skill::Spearfishing::max_attack;
        this->skill2_crit = enemy_settings::Pelagic_Grouper::skill::Spearfishing::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Pelagic_Grouper::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Pelagic_Grouper::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Pelagic_Grouper::blight;
        this->bleed = enemy_settings::Pelagic_Grouper::bleed;
        this->stun = enemy_settings::Pelagic_Grouper::stun;
        this->dodge = enemy_settings::Pelagic_Grouper::dodge;
        this->prot = 0; 
    }

    Pelagic_Grouper::Pelagic_Grouper(const Pelagic_Grouper& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    Pelagic_Grouper& enemys::Pelagic_Grouper::operator=(const Pelagic_Grouper& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Pelagic_Grouper::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Pelagic_Grouper::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Cultist_Brawler::Cultist_Brawler(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Cultist_Brawler::skill::Rend_for_the_Old_Gods::name;
        this->skill1_targets = enemy_settings::Cultist_Brawler::skill::Rend_for_the_Old_Gods::Target;
        this->skill1_min_attack = enemy_settings::Cultist_Brawler::skill::Rend_for_the_Old_Gods::min_attack;
        this->skill1_max_attack = enemy_settings::Cultist_Brawler::skill::Rend_for_the_Old_Gods::max_attack;
        this->skill1_crit = enemy_settings::Cultist_Brawler::skill::Rend_for_the_Old_Gods::crit;
        this->skill2_name = enemy_settings::Cultist_Brawler::skill::Stumbling_Scratch::name;
        this->skill2_targets = enemy_settings::Cultist_Brawler::skill::Stumbling_Scratch::Target;
        this->skill2_min_attack = enemy_settings::Cultist_Brawler::skill::Stumbling_Scratch::min_attack;
        this->skill2_max_attack = enemy_settings::Cultist_Brawler::skill::Stumbling_Scratch::max_attack;
        this->skill2_crit = enemy_settings::Cultist_Brawler::skill::Stumbling_Scratch::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Cultist_Brawler::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Cultist_Brawler::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Cultist_Brawler::blight;
        this->bleed = enemy_settings::Cultist_Brawler::bleed;
        this->stun = enemy_settings::Cultist_Brawler::stun;
        this->dodge = enemy_settings::Cultist_Brawler::dodge;
        this->prot = 0; 
    }

    enemys::Cultist_Brawler::Cultist_Brawler(const Cultist_Brawler& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Cultist_Brawler& enemys::Cultist_Brawler::operator=(const Cultist_Brawler& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Cultist_Brawler::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {   
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Cultist_Brawler::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Cultist_Acolyte::Cultist_Acolyte(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::name;
        this->skill1_targets = enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::Target;
        this->skill1_min_attack = enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::min_attack;
        this->skill1_max_attack = enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::max_attack;
        this->skill1_crit = enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::crit;
        this->skill2_name = enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::name;
        this->skill2_targets = enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::Target;
        this->skill2_min_attack = enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::min_attack;
        this->skill2_max_attack = enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::max_attack;
        this->skill2_crit = enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Cultist_Acolyte::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Cultist_Acolyte::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Cultist_Acolyte::blight;
        this->bleed = enemy_settings::Cultist_Acolyte::bleed;
        this->stun = enemy_settings::Cultist_Acolyte::stun;
        this->dodge = enemy_settings::Cultist_Acolyte::dodge;
        this->prot = 0; 
    }

    enemys::Cultist_Acolyte::Cultist_Acolyte(const Cultist_Acolyte& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Cultist_Acolyte& enemys::Cultist_Acolyte::operator=(const Cultist_Acolyte& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Cultist_Acolyte::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {   
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Cultist_Acolyte::skill::Stressful_Incantation::stress << ".\n";
            }
        }
    }

    void Cultist_Acolyte::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Cultist_Acolyte::skill::Eldritch_Push::stress << ".\n";
            }
        }
    }

    Madman::Madman(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Madman::skill::Doomsay::name;
        this->skill1_targets = enemy_settings::Madman::skill::Doomsay::Target;
        this->skill1_min_attack = enemy_settings::Madman::skill::Doomsay::min_attack;
        this->skill1_max_attack = enemy_settings::Madman::skill::Doomsay::max_attack;
        this->skill1_crit = enemy_settings::Madman::skill::Doomsay::crit;
        this->skill2_name = enemy_settings::Madman::skill::Accusation::name;
        this->skill2_targets = enemy_settings::Madman::skill::Accusation::Target;
        this->skill2_min_attack = enemy_settings::Madman::skill::Accusation::min_attack;
        this->skill2_max_attack = enemy_settings::Madman::skill::Accusation::max_attack;
        this->skill2_crit = enemy_settings::Madman::skill::Accusation::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Madman::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Madman::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Madman::blight;
        this->bleed = enemy_settings::Madman::bleed;
        this->stun = enemy_settings::Madman::stun;
        this->dodge = enemy_settings::Madman::dodge;
        this->prot = 0; 
    }

    enemys::Madman::Madman(const Madman& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Madman& enemys::Madman::operator=(const Madman& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Madman::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "'\n";
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {   
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            for (auto* obj : team) {
                if (auto* h = dynamic_cast<Ahero*>(obj)) {
                    h->takeStress(enemy_settings::Madman::skill::Doomsay::stress);
                    std::cout << obj->getName() << "'s stress increased " << enemy_settings::Madman::skill::Doomsay::stress << ".\n";
                }
            }
        }
    }

    void Madman::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Madman::skill::Accusation::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Madman::skill::Accusation::stress << ".\n";
            }
        }
    }

    Bone_Soldier::Bone_Soldier(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Bone_Soldier::skill::Graveyard_Slash::name;
        this->skill1_targets = enemy_settings::Bone_Soldier::skill::Graveyard_Slash::Target;
        this->skill1_min_attack = enemy_settings::Bone_Soldier::skill::Graveyard_Slash::min_attack;
        this->skill1_max_attack = enemy_settings::Bone_Soldier::skill::Graveyard_Slash::max_attack;
        this->skill1_crit = enemy_settings::Bone_Soldier::skill::Graveyard_Slash::crit;
        this->skill2_name = enemy_settings::Bone_Soldier::skill::Graveyard_Stumble::name;
        this->skill2_targets = enemy_settings::Bone_Soldier::skill::Graveyard_Stumble::Target;
        this->skill2_min_attack = enemy_settings::Bone_Soldier::skill::Graveyard_Stumble::min_attack;
        this->skill2_max_attack = enemy_settings::Bone_Soldier::skill::Graveyard_Stumble::max_attack;
        this->skill2_crit = enemy_settings::Bone_Soldier::skill::Graveyard_Stumble::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Bone_Soldier::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Bone_Soldier::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Bone_Soldier::blight;
        this->bleed = enemy_settings::Bone_Soldier::bleed;
        this->stun = enemy_settings::Bone_Soldier::stun;
        this->dodge = enemy_settings::Bone_Soldier::dodge;
        this->prot = 0; 
    }

    enemys::Bone_Soldier::Bone_Soldier(const Bone_Soldier& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Bone_Soldier& enemys::Bone_Soldier::operator=(const Bone_Soldier& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Bone_Soldier::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Bone_Soldier::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Bone_Courtier::Bone_Courtier(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Bone_Courtier::skill::Tempting_Goblet::name;
        this->skill1_targets = enemy_settings::Bone_Courtier::skill::Tempting_Goblet::Target;
        this->skill1_min_attack = enemy_settings::Bone_Courtier::skill::Tempting_Goblet::min_attack;
        this->skill1_max_attack = enemy_settings::Bone_Courtier::skill::Tempting_Goblet::max_attack;
        this->skill1_crit = enemy_settings::Bone_Courtier::skill::Tempting_Goblet::crit;
        this->skill2_name = enemy_settings::Bone_Courtier::skill::Knife_in_The_Dark::name;
        this->skill2_targets = enemy_settings::Bone_Courtier::skill::Knife_in_The_Dark::Target;
        this->skill2_min_attack = enemy_settings::Bone_Courtier::skill::Knife_in_The_Dark::min_attack;
        this->skill2_max_attack = enemy_settings::Bone_Courtier::skill::Knife_in_The_Dark::max_attack;
        this->skill2_crit = enemy_settings::Bone_Courtier::skill::Knife_in_The_Dark::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Bone_Courtier::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Bone_Courtier::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Bone_Courtier::blight;
        this->bleed = enemy_settings::Bone_Courtier::bleed;
        this->stun = enemy_settings::Bone_Courtier::stun;
        this->dodge = enemy_settings::Bone_Courtier::dodge;
        this->prot = 0; 
    }

    enemys::Bone_Courtier::Bone_Courtier(const Bone_Courtier& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Bone_Courtier& enemys::Bone_Courtier::operator=(const Bone_Courtier& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Bone_Courtier::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {   
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Bone_Courtier::skill::Tempting_Goblet::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Bone_Courtier::skill::Tempting_Goblet::stress << ".\n";
            }
        }
    }

    void Bone_Courtier::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Bone_Arbalist::Bone_Arbalist(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Bone_Arbalist::skill::Shoot::name;
        this->skill1_targets = enemy_settings::Bone_Arbalist::skill::Shoot::Target;
        this->skill1_min_attack = enemy_settings::Bone_Arbalist::skill::Shoot::min_attack;
        this->skill1_max_attack = enemy_settings::Bone_Arbalist::skill::Shoot::max_attack;
        this->skill1_crit = enemy_settings::Bone_Arbalist::skill::Shoot::crit;
        this->skill2_name = enemy_settings::Bone_Arbalist::skill::Quarre::name;
        this->skill2_targets = enemy_settings::Bone_Arbalist::skill::Quarre::Target;
        this->skill2_min_attack = enemy_settings::Bone_Arbalist::skill::Quarre::min_attack;
        this->skill2_max_attack = enemy_settings::Bone_Arbalist::skill::Quarre::max_attack;
        this->skill2_crit = enemy_settings::Bone_Arbalist::skill::Quarre::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Bone_Arbalist::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Bone_Arbalist::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Bone_Arbalist::blight;
        this->bleed = enemy_settings::Bone_Arbalist::bleed;
        this->stun = enemy_settings::Bone_Arbalist::stun;
        this->dodge = enemy_settings::Bone_Arbalist::dodge;
        this->prot = 0; 
    }

    enemys::Bone_Arbalist::Bone_Arbalist(const Bone_Arbalist& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Bone_Arbalist& enemys::Bone_Arbalist::operator=(const Bone_Arbalist& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Bone_Arbalist::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Bone_Arbalist::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Bone_Defender::Bone_Defender(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Bone_Defender::skill::Axeblade::name;
        this->skill1_targets = enemy_settings::Bone_Defender::skill::Axeblade::Target;
        this->skill1_min_attack = enemy_settings::Bone_Defender::skill::Axeblade::min_attack;
        this->skill1_max_attack = enemy_settings::Bone_Defender::skill::Axeblade::max_attack;
        this->skill1_crit = enemy_settings::Bone_Defender::skill::Axeblade::crit;
        this->skill2_name = enemy_settings::Bone_Defender::skill::Clumsy_Axeblade::name;
        this->skill2_targets = enemy_settings::Bone_Defender::skill::Clumsy_Axeblade::Target;
        this->skill2_min_attack = enemy_settings::Bone_Defender::skill::Clumsy_Axeblade::min_attack;
        this->skill2_max_attack = enemy_settings::Bone_Defender::skill::Clumsy_Axeblade::max_attack;
        this->skill2_crit = enemy_settings::Bone_Defender::skill::Clumsy_Axeblade::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Bone_Defender::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Bone_Defender::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Bone_Defender::blight;
        this->bleed = enemy_settings::Bone_Defender::bleed;
        this->stun = enemy_settings::Bone_Defender::stun;
        this->dodge = enemy_settings::Bone_Defender::dodge;
        this->prot = enemy_settings::Bone_Defender::prot; 
    }

    enemys::Bone_Defender::Bone_Defender(const Bone_Defender& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Bone_Defender& enemys::Bone_Defender::operator=(const Bone_Defender& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Bone_Defender::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Bone_Defender::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Swine_Chopper::Swine_Chopper(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Swine_Chopper::skill::Butcher_Cut::name;
        this->skill1_targets = enemy_settings::Swine_Chopper::skill::Butcher_Cut::Target;
        this->skill1_min_attack = enemy_settings::Swine_Chopper::skill::Butcher_Cut::min_attack;
        this->skill1_max_attack = enemy_settings::Swine_Chopper::skill::Butcher_Cut::max_attack;
        this->skill1_crit = enemy_settings::Swine_Chopper::skill::Butcher_Cut::crit;
        this->skill2_name = enemy_settings::Swine_Chopper::skill::Ball_And_Chain::name;
        this->skill2_targets = enemy_settings::Swine_Chopper::skill::Ball_And_Chain::Target;
        this->skill2_min_attack = enemy_settings::Swine_Chopper::skill::Ball_And_Chain::min_attack;
        this->skill2_max_attack = enemy_settings::Swine_Chopper::skill::Ball_And_Chain::max_attack;
        this->skill2_crit = enemy_settings::Swine_Chopper::skill::Ball_And_Chain::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Swine_Chopper::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Swine_Chopper::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Swine_Chopper::blight;
        this->bleed = enemy_settings::Swine_Chopper::bleed;
        this->stun = enemy_settings::Swine_Chopper::stun;
        this->dodge = enemy_settings::Swine_Chopper::dodge;
        this->prot = 0.25;
    }

    enemys::Swine_Chopper::Swine_Chopper(const Swine_Chopper& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Swine_Chopper& enemys::Swine_Chopper::operator=(const Swine_Chopper& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Swine_Chopper::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Swine_Chopper::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Swine_Slasher::Swine_Slasher(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Swine_Slasher::skill::Hook_Where_It_Hurts::name;
        this->skill1_targets = enemy_settings::Swine_Slasher::skill::Hook_Where_It_Hurts::Target;
        this->skill1_min_attack = enemy_settings::Swine_Slasher::skill::Hook_Where_It_Hurts::min_attack;
        this->skill1_max_attack = enemy_settings::Swine_Slasher::skill::Hook_Where_It_Hurts::max_attack;
        this->skill1_crit = enemy_settings::Swine_Slasher::skill::Hook_Where_It_Hurts::crit;
        this->skill2_name = enemy_settings::Swine_Slasher::skill::Dead_Weight::name;
        this->skill2_targets = enemy_settings::Swine_Slasher::skill::Dead_Weight::Target;
        this->skill2_min_attack = enemy_settings::Swine_Slasher::skill::Dead_Weight::min_attack;
        this->skill2_max_attack = enemy_settings::Swine_Slasher::skill::Dead_Weight::max_attack;
        this->skill2_crit = enemy_settings::Swine_Slasher::skill::Dead_Weight::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Swine_Slasher::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Swine_Slasher::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Swine_Slasher::blight;
        this->bleed = enemy_settings::Swine_Slasher::bleed;
        this->stun = enemy_settings::Swine_Slasher::stun;
        this->dodge = enemy_settings::Swine_Slasher::dodge;
        this->prot = 0;
    }

    enemys::Swine_Slasher::Swine_Slasher(const Swine_Slasher& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Swine_Slasher& enemys::Swine_Slasher::operator=(const Swine_Slasher& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Swine_Slasher::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Swine_Slasher::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Swine_Drummer::Swine_Drummer(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Swine_Drummer::skill::Drum_of_Doom::name;
        this->skill1_targets = enemy_settings::Swine_Drummer::skill::Drum_of_Doom::Target;
        this->skill1_min_attack = enemy_settings::Swine_Drummer::skill::Drum_of_Doom::min_attack;
        this->skill1_max_attack = enemy_settings::Swine_Drummer::skill::Drum_of_Doom::max_attack;
        this->skill1_crit = enemy_settings::Swine_Drummer::skill::Drum_of_Doom::crit;
        this->skill2_name = enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::name;
        this->skill2_targets = enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::Target;
        this->skill2_min_attack = enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::min_attack;
        this->skill2_max_attack = enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::max_attack;
        this->skill2_crit = enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Swine_Drummer::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Swine_Drummer::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Swine_Drummer::blight;
        this->bleed = enemy_settings::Swine_Drummer::bleed;
        this->stun = enemy_settings::Swine_Drummer::stun;
        this->dodge = enemy_settings::Swine_Drummer::dodge;
        this->prot = 0;
    }

    enemys::Swine_Drummer::Swine_Drummer(const Swine_Drummer& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Swine_Drummer& enemys::Swine_Drummer::operator=(const Swine_Drummer& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Swine_Drummer::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "'\n";
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            for (auto* obj : team) {
                if (auto* h = dynamic_cast<Ahero*>(obj)) {
                    h->takeDamage(damage);
                    std::cout << "\n" << this->name << " damage " << h->getName() << " " << std::to_string(damage) << "\n";
                    h->takeStress(enemy_settings::Swine_Drummer::skill::Drum_of_Doom::stress);
                    std::cout << obj->getName() << "'s stress increased " << enemy_settings::Swine_Drummer::skill::Drum_of_Doom::stress << ".\n";
                }
            }
        }
    }

    void Swine_Drummer::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Swine_Drummer::skill::Drum_of_Debilitation::stress << ".\n";
            }
        }
    }

    Carrion_Eater::Carrion_Eater(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Carrion_Eater::skill::Munch::name;
        this->skill1_targets = enemy_settings::Carrion_Eater::skill::Munch::Target;
        this->skill1_min_attack = enemy_settings::Carrion_Eater::skill::Munch::min_attack;
        this->skill1_max_attack = enemy_settings::Carrion_Eater::skill::Munch::max_attack;
        this->skill1_crit = enemy_settings::Carrion_Eater::skill::Munch::crit;
        this->skill2_name = enemy_settings::Carrion_Eater::skill::Munch_again::name;
        this->skill2_targets = enemy_settings::Carrion_Eater::skill::Munch_again::Target;
        this->skill2_min_attack = enemy_settings::Carrion_Eater::skill::Munch_again::min_attack;
        this->skill2_max_attack = enemy_settings::Carrion_Eater::skill::Munch_again::max_attack;
        this->skill2_crit = enemy_settings::Carrion_Eater::skill::Munch_again::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Carrion_Eater::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Carrion_Eater::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Carrion_Eater::blight;
        this->bleed = enemy_settings::Carrion_Eater::bleed;
        this->stun = enemy_settings::Carrion_Eater::stun;
        this->dodge = enemy_settings::Carrion_Eater::dodge;
        this->prot = 0; 
    }

    enemys::Carrion_Eater::Carrion_Eater(const Carrion_Eater& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Carrion_Eater& enemys::Carrion_Eater::operator=(const Carrion_Eater& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Carrion_Eater::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Carrion_Eater::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Brigand_Cutthroat::Brigand_Cutthroat(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Brigand_Cutthroat::skill::Shank::name;
        this->skill1_targets = enemy_settings::Brigand_Cutthroat::skill::Shank::Target;
        this->skill1_min_attack = enemy_settings::Brigand_Cutthroat::skill::Shank::min_attack;
        this->skill1_max_attack = enemy_settings::Brigand_Cutthroat::skill::Shank::max_attack;
        this->skill1_crit = enemy_settings::Brigand_Cutthroat::skill::Shank::crit;
        this->skill2_name = enemy_settings::Brigand_Cutthroat::skill::Harmless_Poke::name;
        this->skill2_targets = enemy_settings::Brigand_Cutthroat::skill::Harmless_Poke::Target;
        this->skill2_min_attack = enemy_settings::Brigand_Cutthroat::skill::Harmless_Poke::min_attack;
        this->skill2_max_attack = enemy_settings::Brigand_Cutthroat::skill::Harmless_Poke::max_attack;
        this->skill2_crit = enemy_settings::Brigand_Cutthroat::skill::Harmless_Poke::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Brigand_Cutthroat::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Brigand_Cutthroat::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Brigand_Cutthroat::blight;
        this->bleed = enemy_settings::Brigand_Cutthroat::bleed;
        this->stun = enemy_settings::Brigand_Cutthroat::stun;
        this->dodge = enemy_settings::Brigand_Cutthroat::dodge;
        this->prot = 0; 
    }

    enemys::Brigand_Cutthroat::Brigand_Cutthroat(const Brigand_Cutthroat& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Brigand_Cutthroat& enemys::Brigand_Cutthroat::operator=(const Brigand_Cutthroat& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Brigand_Cutthroat::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Brigand_Cutthroat::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Brigand_Fusilier::Brigand_Fusilier(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Brigand_Fusilier::skill::Blanket_Fire::name;
        this->skill1_targets = enemy_settings::Brigand_Fusilier::skill::Blanket_Fire::Target;
        this->skill1_min_attack = enemy_settings::Brigand_Fusilier::skill::Blanket_Fire::min_attack;
        this->skill1_max_attack = enemy_settings::Brigand_Fusilier::skill::Blanket_Fire::max_attack;
        this->skill1_crit = enemy_settings::Brigand_Fusilier::skill::Blanket_Fire::crit;
        this->skill2_name = enemy_settings::Brigand_Fusilier::skill::Rushed_Shot::name;
        this->skill2_targets = enemy_settings::Brigand_Fusilier::skill::Rushed_Shot::Target;
        this->skill2_min_attack = enemy_settings::Brigand_Fusilier::skill::Rushed_Shot::min_attack;
        this->skill2_max_attack = enemy_settings::Brigand_Fusilier::skill::Rushed_Shot::max_attack;
        this->skill2_crit = enemy_settings::Brigand_Fusilier::skill::Rushed_Shot::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Brigand_Fusilier::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Brigand_Fusilier::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Brigand_Fusilier::blight;
        this->bleed = enemy_settings::Brigand_Fusilier::bleed;
        this->stun = enemy_settings::Brigand_Fusilier::stun;
        this->dodge = enemy_settings::Brigand_Fusilier::dodge;
        this->prot = 0; 
    }

    enemys::Brigand_Fusilier::Brigand_Fusilier(const Brigand_Fusilier& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Brigand_Fusilier& enemys::Brigand_Fusilier::operator=(const Brigand_Fusilier& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Brigand_Fusilier::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "'\n";
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            for (auto* obj : team) {
                if (auto* h = dynamic_cast<Ahero*>(obj)) {
                    h->takeDamage(damage);
                    std::cout << "\n" << this->name << " damage " << h->getName() << " " << std::to_string(damage) << "\n";
                }
            }
        }
    }

    void Brigand_Fusilier::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Brigand_Bloodletter::Brigand_Bloodletter(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Brigand_Bloodletter::skill::Punishment::name;
        this->skill1_targets = enemy_settings::Brigand_Bloodletter::skill::Punishment::Target;
        this->skill1_min_attack = enemy_settings::Brigand_Bloodletter::skill::Punishment::min_attack;
        this->skill1_max_attack = enemy_settings::Brigand_Bloodletter::skill::Punishment::max_attack;
        this->skill1_crit = enemy_settings::Brigand_Bloodletter::skill::Punishment::crit;
        this->skill2_name = enemy_settings::Brigand_Bloodletter::skill::Point_Blank_Shot::name;
        this->skill2_targets = enemy_settings::Brigand_Bloodletter::skill::Point_Blank_Shot::Target;
        this->skill2_min_attack = enemy_settings::Brigand_Bloodletter::skill::Point_Blank_Shot::min_attack;
        this->skill2_max_attack = enemy_settings::Brigand_Bloodletter::skill::Point_Blank_Shot::max_attack;
        this->skill2_crit = enemy_settings::Brigand_Bloodletter::skill::Point_Blank_Shot::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Brigand_Bloodletter::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Brigand_Bloodletter::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Brigand_Bloodletter::blight;
        this->bleed = enemy_settings::Brigand_Bloodletter::bleed;
        this->stun = enemy_settings::Brigand_Bloodletter::stun;
        this->dodge = enemy_settings::Brigand_Bloodletter::dodge;
        this->prot = 0; 
    }

    enemys::Brigand_Bloodletter::Brigand_Bloodletter(const Brigand_Bloodletter& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Brigand_Bloodletter& enemys::Brigand_Bloodletter::operator=(const Brigand_Bloodletter& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Brigand_Bloodletter::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Brigand_Bloodletter::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

        Pelagic_Shaman::Pelagic_Shaman(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Pelagic_Shaman::skill::Stress_Wave::name;
        this->skill1_targets = enemy_settings::Pelagic_Shaman::skill::Stress_Wave::Target;
        this->skill1_min_attack = enemy_settings::Pelagic_Shaman::skill::Stress_Wave::min_attack;
        this->skill1_max_attack = enemy_settings::Pelagic_Shaman::skill::Stress_Wave::max_attack;
        this->skill1_crit = enemy_settings::Pelagic_Shaman::skill::Stress_Wave::crit;
        this->skill2_name = enemy_settings::Pelagic_Shaman::skill::Ceremonial_Cut::name;
        this->skill2_targets = enemy_settings::Pelagic_Shaman::skill::Ceremonial_Cut::Target;
        this->skill2_min_attack = enemy_settings::Pelagic_Shaman::skill::Ceremonial_Cut::min_attack;
        this->skill2_max_attack = enemy_settings::Pelagic_Shaman::skill::Ceremonial_Cut::max_attack;
        this->skill2_crit = enemy_settings::Pelagic_Shaman::skill::Ceremonial_Cut::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Pelagic_Shaman::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Pelagic_Shaman::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Pelagic_Shaman::blight;
        this->bleed = enemy_settings::Pelagic_Shaman::bleed;
        this->stun = enemy_settings::Pelagic_Shaman::stun;
        this->dodge = enemy_settings::Pelagic_Shaman::dodge;
        this->prot = 0; 
    }

    enemys::Pelagic_Shaman::Pelagic_Shaman(const Pelagic_Shaman& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Pelagic_Shaman& enemys::Pelagic_Shaman::operator=(const Pelagic_Shaman& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Pelagic_Shaman::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->takeStress(enemy_settings::Pelagic_Shaman::skill::Stress_Wave::stress);
                std::cout << team[target_pos]->getName() << "'s stress increased " << enemy_settings::Pelagic_Shaman::skill::Stress_Wave::stress << ".\n";
            }
        }
    }


    void Pelagic_Shaman::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    Pelagic_Guardian::Pelagic_Guardian(std::string enemy_name, unsigned position_inteam) {
        this->skill1_name = enemy_settings::Pelagic_Guardian::skill::Octocestus::name;
        this->skill1_targets = enemy_settings::Pelagic_Guardian::skill::Octocestus::Target;
        this->skill1_min_attack = enemy_settings::Pelagic_Guardian::skill::Octocestus::min_attack;
        this->skill1_max_attack = enemy_settings::Pelagic_Guardian::skill::Octocestus::max_attack;
        this->skill1_crit = enemy_settings::Pelagic_Guardian::skill::Octocestus::crit;
        this->skill2_name = enemy_settings::Pelagic_Guardian::skill::Sea_Breeze::name;
        this->skill2_targets = enemy_settings::Pelagic_Guardian::skill::Sea_Breeze::Target;
        this->skill2_min_attack = enemy_settings::Pelagic_Guardian::skill::Sea_Breeze::min_attack;
        this->skill2_max_attack = enemy_settings::Pelagic_Guardian::skill::Sea_Breeze::max_attack;
        this->skill2_crit = enemy_settings::Pelagic_Guardian::skill::Sea_Breeze::crit;
        this->name = enemy_name;
        this->description = "";
        this->is_dead = false;
        this->maxHealth = enemy_settings::Pelagic_Guardian::maxHealth;
        this->health = this->maxHealth;
        this->speed = enemy_settings::Pelagic_Guardian::speed;
        this->round_speed = this->speed;
        this->position_inteam = position_inteam;
        this->round_finsh = false; 
        this->blight = enemy_settings::Pelagic_Guardian::blight;
        this->bleed = enemy_settings::Pelagic_Guardian::bleed;
        this->stun = enemy_settings::Pelagic_Guardian::stun;
        this->dodge = enemy_settings::Pelagic_Guardian::dodge;
        this->prot = 0; 
    }

    enemys::Pelagic_Guardian::Pelagic_Guardian(const Pelagic_Guardian& other) :
        Aenemy(other),
        skill1_min_attack(other.skill1_min_attack),
        skill1_max_attack(other.skill1_max_attack),
        skill1_crit(other.skill1_crit),
        skill2_min_attack(other.skill2_min_attack),
        skill2_max_attack(other.skill2_max_attack),
        skill2_crit(other.skill2_crit)
    {}

    enemys::Pelagic_Guardian& enemys::Pelagic_Guardian::operator=(const Pelagic_Guardian& other) {
        if (this != &other) {
            Aenemy::operator=(other);
            skill1_min_attack = other.skill1_min_attack;
            skill1_max_attack = other.skill1_max_attack;
            skill1_crit = other.skill1_crit;
            skill2_min_attack = other.skill2_min_attack;
            skill2_max_attack = other.skill2_max_attack;
            skill2_crit = other.skill2_crit;
        }
        return *this;
    }

    void Pelagic_Guardian::skill1(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill1_name << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill1_min_attack, this->skill1_max_attack);
            if (randomFunc::get_persent_bool(this->skill1_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }

    void Pelagic_Guardian::skill2(std::vector<ICharacter*>& team, std::vector<ICharacter*>& other_team, unsigned target_pos) {
        std::cout << this->name << " use '" << this->skill2_name  << "' to " << team[target_pos]->getName();
        if (target_pos > team.size() - 1 || randomFunc::get_persent_bool(team[target_pos]->getDodge())) {
            std::cout << "\nMiss!\n";
            if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                h->stressHealing(5);
                std::cout << team[target_pos]->getName() << "'s stress decreased 5.\n";
            }
        } else {
            unsigned damage = randomFunc::get_Random_Num(this->skill2_min_attack, this->skill2_max_attack);
            if (randomFunc::get_persent_bool(this->skill2_crit))
            {
                damage *= 1.5;
                std::cout << "\nCrit!\n";
                if (auto* h = dynamic_cast<Ahero*>(team[target_pos])) {
                    h->takeStress(5);
                    std::cout << team[target_pos]->getName() << "'s stress increased 5.\n";
                }
            }
            team[target_pos]->takeDamage(damage);
            std::cout << "\n" << this->name << " damage " << team[target_pos]->getName() << " " << std::to_string(damage) << "\n";
        }
    }
}